using System;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("PowerProcessor")]
	public class PowerProcessor : MonoClass
	{
		public static string ATTACK_SPELL_CONTROLLER_PREFAB_PATH => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "PowerProcessor", "ATTACK_SPELL_CONTROLLER_PREFAB_PATH");

		public static string SECRET_SPELL_CONTROLLER_PREFAB_PATH => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "PowerProcessor", "SECRET_SPELL_CONTROLLER_PREFAB_PATH");

		public static string JOUST_SPELL_CONTROLLER_PREFAB_PATH => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "PowerProcessor", "JOUST_SPELL_CONTROLLER_PREFAB_PATH");

		public static string RITUAL_SPELL_CONTROLLER_PREFAB_PATH => MonoClass.smethod_8(TritonHs.MainAssemblyPath, "", "PowerProcessor", "RITUAL_SPELL_CONTROLLER_PREFAB_PATH");

		public int m_nextTaskListId => method_2<int>("m_nextTaskListId");

		public bool m_buildingTaskList => method_2<bool>("m_buildingTaskList");

		public PowerTaskList m_currentTaskList => method_3<PowerTaskList>("m_currentTaskList");

		public bool m_historyBlocking => method_2<bool>("m_historyBlocking");

		public PowerTaskList m_historyBlockingTaskList => method_3<PowerTaskList>("m_historyBlockingTaskList");

		public PowerTaskList m_busyTaskList => method_3<PowerTaskList>("m_busyTaskList");

		public PowerTaskList m_earlyConcedeTaskList => method_3<PowerTaskList>("m_earlyConcedeTaskList");

		public bool m_handledFirstEarlyConcede => method_2<bool>("m_handledFirstEarlyConcede");

		public PowerTaskList m_gameOverTaskList => method_3<PowerTaskList>("m_gameOverTaskList");

		public PowerProcessor(IntPtr address, string className)
			: base(address, className)
		{
		}

		public PowerProcessor(IntPtr address)
			: this(address, "PowerProcessor")
		{
		}

		public void Clear()
		{
			method_8("Clear");
		}

		public bool IsBuildingTaskList()
		{
			return method_11<bool>("IsBuildingTaskList", Array.Empty<object>());
		}

		public PowerTaskList GetCurrentTaskList()
		{
			return method_14<PowerTaskList>("GetCurrentTaskList", Array.Empty<object>());
		}

		public void OnMetaData(Network.HistMetaData metaData)
		{
			method_8("OnMetaData", metaData);
		}

		public bool IsHistoryBlocking()
		{
			return method_11<bool>("IsHistoryBlocking", Array.Empty<object>());
		}

		public PowerTaskList GetHistoryBlockingTaskList()
		{
			return method_14<PowerTaskList>("GetHistoryBlockingTaskList", Array.Empty<object>());
		}

		public void ForceStopHistoryBlocking()
		{
			method_8("ForceStopHistoryBlocking");
		}

		public PowerTaskList GetLatestUnendedTaskList()
		{
			return method_14<PowerTaskList>("GetLatestUnendedTaskList", Array.Empty<object>());
		}

		public PowerTaskList GetLastTaskList()
		{
			return method_14<PowerTaskList>("GetLastTaskList", Array.Empty<object>());
		}

		public PowerTaskList GetEarlyConcedeTaskList()
		{
			return method_14<PowerTaskList>("GetEarlyConcedeTaskList", Array.Empty<object>());
		}

		public bool HasEarlyConcedeTaskList()
		{
			return method_11<bool>("HasEarlyConcedeTaskList", Array.Empty<object>());
		}

		public PowerTaskList GetGameOverTaskList()
		{
			return method_14<PowerTaskList>("GetGameOverTaskList", Array.Empty<object>());
		}

		public bool HasGameOverTaskList()
		{
			return method_11<bool>("HasGameOverTaskList", Array.Empty<object>());
		}

		public bool CanDoTask(PowerTask task)
		{
			return method_11<bool>("CanDoTask", new object[1] { task });
		}

		public bool HasTaskLists()
		{
			return method_11<bool>("HasTaskLists", Array.Empty<object>());
		}

		public bool HasTaskList(PowerTaskList taskList)
		{
			return method_11<bool>("HasTaskList", new object[1] { taskList });
		}

		public void ProcessPowerQueue()
		{
			method_8("ProcessPowerQueue");
		}

		public int GetNextTaskListId()
		{
			return method_11<int>("GetNextTaskListId", Array.Empty<object>());
		}

		public void EnqueueTaskList(PowerTaskList taskList)
		{
			method_8("EnqueueTaskList", taskList);
		}

		public void OnWillProcessTaskList(PowerTaskList taskList)
		{
			method_8("OnWillProcessTaskList", taskList);
		}

		public string FindRevealedCardId(PowerTaskList taskList)
		{
			return method_13("FindRevealedCardId", taskList);
		}

		public void OnProcessTaskList()
		{
			method_8("OnProcessTaskList");
		}

		public void PrepareHistoryForCurrentTaskList()
		{
			method_8("PrepareHistoryForCurrentTaskList");
		}

		public void OnBigCardFinished()
		{
			method_8("OnBigCardFinished");
		}

		public bool ShouldShowPlayedBigCard(Entity sourceEntity)
		{
			return method_11<bool>("ShouldShowPlayedBigCard", new object[1] { sourceEntity });
		}

		public bool ShouldShowTriggeredBigCard(Entity sourceEntity)
		{
			return method_11<bool>("ShouldShowTriggeredBigCard", new object[1] { sourceEntity });
		}

		public PowerTaskList GetTriggerTaskListThatShouldCompleteHistoryEntry()
		{
			return method_14<PowerTaskList>("GetTriggerTaskListThatShouldCompleteHistoryEntry", Array.Empty<object>());
		}

		public bool CanEarlyConcede()
		{
			return method_11<bool>("CanEarlyConcede", Array.Empty<object>());
		}

		public void DoEarlyConcedeVisuals()
		{
			method_8("DoEarlyConcedeVisuals");
		}

		public void CancelSpellsForEarlyConcede(PowerTaskList taskList)
		{
			method_8("CancelSpellsForEarlyConcede", taskList);
		}

		public void StartCurrentTaskList()
		{
			method_8("StartCurrentTaskList");
		}

		public void DoCurrentTaskList()
		{
			method_8("DoCurrentTaskList");
		}

		public void EndCurrentTaskList()
		{
			method_8("EndCurrentTaskList");
		}

		public void AddCthunToHistory()
		{
			method_8("AddCthunToHistory");
		}

		public bool DoTaskListWithSpellController(GameState state, PowerTaskList taskList, Entity sourceEntity)
		{
			return method_11<bool>("DoTaskListWithSpellController", new object[3] { state, taskList, sourceEntity });
		}

		public void CheckDeactivatePlaySpellForSpellPlayBlock(PowerTaskList taskList)
		{
			method_8("CheckDeactivatePlaySpellForSpellPlayBlock", taskList);
		}

		public bool DoTaskListUsingController(SpellController spellController, PowerTaskList taskList)
		{
			return method_11<bool>("DoTaskListUsingController", new object[2] { spellController, taskList });
		}

		public void OnSpellControllerFinishedTaskList(SpellController spellController)
		{
			method_8("OnSpellControllerFinishedTaskList", spellController);
		}

		public void OnSpellControllerFinished(SpellController spellController)
		{
			method_8("OnSpellControllerFinished", spellController);
		}

		public AttackSpellController CreateAttackSpellController(PowerTaskList taskList)
		{
			return method_14<AttackSpellController>("CreateAttackSpellController", new object[1] { taskList });
		}

		public SecretSpellController CreateSecretSpellController(PowerTaskList taskList)
		{
			return method_14<SecretSpellController>("CreateSecretSpellController", new object[1] { taskList });
		}

		public PowerSpellController CreatePowerSpellController(PowerTaskList taskList)
		{
			return method_14<PowerSpellController>("CreatePowerSpellController", new object[1] { taskList });
		}

		public TriggerSpellController CreateTriggerSpellController(PowerTaskList taskList)
		{
			return method_14<TriggerSpellController>("CreateTriggerSpellController", new object[1] { taskList });
		}

		public DeathSpellController CreateDeathSpellController(PowerTaskList taskList)
		{
			return method_14<DeathSpellController>("CreateDeathSpellController", new object[1] { taskList });
		}

		public FatigueSpellController CreateFatigueSpellController(PowerTaskList taskList)
		{
			return method_14<FatigueSpellController>("CreateFatigueSpellController", new object[1] { taskList });
		}

		public JoustSpellController CreateJoustSpellController(PowerTaskList taskList)
		{
			return method_14<JoustSpellController>("CreateJoustSpellController", new object[1] { taskList });
		}

		public RitualSpellController CreateRitualSpellController(PowerTaskList taskList)
		{
			return method_14<RitualSpellController>("CreateRitualSpellController", new object[1] { taskList });
		}

		public void DestroySpellController(SpellController spellController)
		{
			method_8("DestroySpellController", spellController);
		}
	}
}
